
// Correction constant value: 3.05176363326609e-05 (00000000000000100)

module hct_arr_1616161 (Z, X, Y);
	
	input [15:0] Y;
	input [15:0] X;
	output [15:0] Z;
	

	wire [15:0] P0;
	wire [15:0] carry1;
	wire [15:0] sum1;
	wire [15:0] P1;
	wire [15:0] carry2;
	wire [15:0] sum2;
	wire [15:0] P2;
	wire [15:0] carry3;
	wire [15:0] sum3;
	wire [15:0] P3;
	wire [15:0] carry4;
	wire [15:0] sum4;
	wire [15:0] P4;
	wire [15:0] carry5;
	wire [15:0] sum5;
	wire [15:0] P5;
	wire [15:0] carry6;
	wire [15:0] sum6;
	wire [15:0] P6;
	wire [15:0] carry7;
	wire [15:0] sum7;
	wire [15:0] P7;
	wire [15:0] carry8;
	wire [15:0] sum8;
	wire [15:0] P8;
	wire [15:0] carry9;
	wire [15:0] sum9;
	wire [15:0] P9;
	wire [15:0] carry10;
	wire [15:0] sum10;
	wire [15:0] P10;
	wire [15:0] carry11;
	wire [15:0] sum11;
	wire [15:0] P11;
	wire [15:0] carry12;
	wire [15:0] sum12;
	wire [15:0] P12;
	wire [15:0] carry13;
	wire [15:0] sum13;
	wire [15:0] P13;
	wire [15:0] carry14;
	wire [15:0] sum14;
	wire [15:0] P14;
	wire [15:0] carry15;
	wire [15:0] sum15;
	wire [15:0] P15;
	wire [15:0] carry16;
	wire [15:0] sum16;


	// generate the partial products.
	and pp1(P0[15], X[15], Y[0]);
	and pp2(sum1[15], X[15], Y[1]);
	and pp3(P1[14], X[14], Y[1]);
	and pp4(sum2[15], X[15], Y[2]);
	and pp5(P2[14], X[14], Y[2]);
	and pp6(P2[13], X[13], Y[2]);
	and pp7(sum3[15], X[15], Y[3]);
	and pp8(P3[14], X[14], Y[3]);
	and pp9(P3[13], X[13], Y[3]);
	and pp10(P3[12], X[12], Y[3]);
	and pp11(sum4[15], X[15], Y[4]);
	and pp12(P4[14], X[14], Y[4]);
	and pp13(P4[13], X[13], Y[4]);
	and pp14(P4[12], X[12], Y[4]);
	and pp15(P4[11], X[11], Y[4]);
	and pp16(sum5[15], X[15], Y[5]);
	and pp17(P5[14], X[14], Y[5]);
	and pp18(P5[13], X[13], Y[5]);
	and pp19(P5[12], X[12], Y[5]);
	and pp20(P5[11], X[11], Y[5]);
	and pp21(P5[10], X[10], Y[5]);
	and pp22(sum6[15], X[15], Y[6]);
	and pp23(P6[14], X[14], Y[6]);
	and pp24(P6[13], X[13], Y[6]);
	and pp25(P6[12], X[12], Y[6]);
	and pp26(P6[11], X[11], Y[6]);
	and pp27(P6[10], X[10], Y[6]);
	and pp28(P6[9], X[9], Y[6]);
	and pp29(sum7[15], X[15], Y[7]);
	and pp30(P7[14], X[14], Y[7]);
	and pp31(P7[13], X[13], Y[7]);
	and pp32(P7[12], X[12], Y[7]);
	and pp33(P7[11], X[11], Y[7]);
	and pp34(P7[10], X[10], Y[7]);
	and pp35(P7[9], X[9], Y[7]);
	and pp36(P7[8], X[8], Y[7]);
	and pp37(sum8[15], X[15], Y[8]);
	and pp38(P8[14], X[14], Y[8]);
	and pp39(P8[13], X[13], Y[8]);
	and pp40(P8[12], X[12], Y[8]);
	and pp41(P8[11], X[11], Y[8]);
	and pp42(P8[10], X[10], Y[8]);
	and pp43(P8[9], X[9], Y[8]);
	and pp44(P8[8], X[8], Y[8]);
	and pp45(P8[7], X[7], Y[8]);
	and pp46(sum9[15], X[15], Y[9]);
	and pp47(P9[14], X[14], Y[9]);
	and pp48(P9[13], X[13], Y[9]);
	and pp49(P9[12], X[12], Y[9]);
	and pp50(P9[11], X[11], Y[9]);
	and pp51(P9[10], X[10], Y[9]);
	and pp52(P9[9], X[9], Y[9]);
	and pp53(P9[8], X[8], Y[9]);
	and pp54(P9[7], X[7], Y[9]);
	and pp55(P9[6], X[6], Y[9]);
	and pp56(sum10[15], X[15], Y[10]);
	and pp57(P10[14], X[14], Y[10]);
	and pp58(P10[13], X[13], Y[10]);
	and pp59(P10[12], X[12], Y[10]);
	and pp60(P10[11], X[11], Y[10]);
	and pp61(P10[10], X[10], Y[10]);
	and pp62(P10[9], X[9], Y[10]);
	and pp63(P10[8], X[8], Y[10]);
	and pp64(P10[7], X[7], Y[10]);
	and pp65(P10[6], X[6], Y[10]);
	and pp66(P10[5], X[5], Y[10]);
	and pp67(sum11[15], X[15], Y[11]);
	and pp68(P11[14], X[14], Y[11]);
	and pp69(P11[13], X[13], Y[11]);
	and pp70(P11[12], X[12], Y[11]);
	and pp71(P11[11], X[11], Y[11]);
	and pp72(P11[10], X[10], Y[11]);
	and pp73(P11[9], X[9], Y[11]);
	and pp74(P11[8], X[8], Y[11]);
	and pp75(P11[7], X[7], Y[11]);
	and pp76(P11[6], X[6], Y[11]);
	and pp77(P11[5], X[5], Y[11]);
	and pp78(P11[4], X[4], Y[11]);
	and pp79(sum12[15], X[15], Y[12]);
	and pp80(P12[14], X[14], Y[12]);
	and pp81(P12[13], X[13], Y[12]);
	and pp82(P12[12], X[12], Y[12]);
	and pp83(P12[11], X[11], Y[12]);
	and pp84(P12[10], X[10], Y[12]);
	and pp85(P12[9], X[9], Y[12]);
	and pp86(P12[8], X[8], Y[12]);
	and pp87(P12[7], X[7], Y[12]);
	and pp88(P12[6], X[6], Y[12]);
	and pp89(P12[5], X[5], Y[12]);
	and pp90(P12[4], X[4], Y[12]);
	and pp91(P12[3], X[3], Y[12]);
	and pp92(sum13[15], X[15], Y[13]);
	and pp93(P13[14], X[14], Y[13]);
	and pp94(P13[13], X[13], Y[13]);
	and pp95(P13[12], X[12], Y[13]);
	and pp96(P13[11], X[11], Y[13]);
	and pp97(P13[10], X[10], Y[13]);
	and pp98(P13[9], X[9], Y[13]);
	and pp99(P13[8], X[8], Y[13]);
	and pp100(P13[7], X[7], Y[13]);
	and pp101(P13[6], X[6], Y[13]);
	and pp102(P13[5], X[5], Y[13]);
	and pp103(P13[4], X[4], Y[13]);
	and pp104(P13[3], X[3], Y[13]);
	and pp105(P13[2], X[2], Y[13]);
	and pp106(sum14[15], X[15], Y[14]);
	and pp107(P14[14], X[14], Y[14]);
	and pp108(P14[13], X[13], Y[14]);
	and pp109(P14[12], X[12], Y[14]);
	and pp110(P14[11], X[11], Y[14]);
	and pp111(P14[10], X[10], Y[14]);
	and pp112(P14[9], X[9], Y[14]);
	and pp113(P14[8], X[8], Y[14]);
	and pp114(P14[7], X[7], Y[14]);
	and pp115(P14[6], X[6], Y[14]);
	and pp116(P14[5], X[5], Y[14]);
	and pp117(P14[4], X[4], Y[14]);
	and pp118(P14[3], X[3], Y[14]);
	and pp119(P14[2], X[2], Y[14]);
	and pp120(P14[1], X[1], Y[14]);
	and pp121(sum15[15], X[15], Y[15]);
	and pp122(P15[14], X[14], Y[15]);
	and pp123(P15[13], X[13], Y[15]);
	and pp124(P15[12], X[12], Y[15]);
	and pp125(P15[11], X[11], Y[15]);
	and pp126(P15[10], X[10], Y[15]);
	and pp127(P15[9], X[9], Y[15]);
	and pp128(P15[8], X[8], Y[15]);
	and pp129(P15[7], X[7], Y[15]);
	and pp130(P15[6], X[6], Y[15]);
	and pp131(P15[5], X[5], Y[15]);
	and pp132(P15[4], X[4], Y[15]);
	and pp133(P15[3], X[3], Y[15]);
	and pp134(P15[2], X[2], Y[15]);
	and pp135(P15[1], X[1], Y[15]);
	and pp136(P15[0], X[0], Y[15]);

	// Array Reduction
	specialized_half_adder  SHA1(carry1[14],sum1[14],P1[14],P0[15]);
	full_adder  FA1(carry2[14],sum2[14],P2[14],sum1[15],carry1[14]);
	specialized_half_adder  SHA2(carry2[13],sum2[13],P2[13],sum1[14]);
	full_adder  FA2(carry3[14],sum3[14],P3[14],sum2[15],carry2[14]);
	full_adder  FA3(carry3[13],sum3[13],P3[13],sum2[14],carry2[13]);
	specialized_half_adder  SHA3(carry3[12],sum3[12],P3[12],sum2[13]);
	full_adder  FA4(carry4[14],sum4[14],P4[14],sum3[15],carry3[14]);
	full_adder  FA5(carry4[13],sum4[13],P4[13],sum3[14],carry3[13]);
	full_adder  FA6(carry4[12],sum4[12],P4[12],sum3[13],carry3[12]);
	specialized_half_adder  SHA4(carry4[11],sum4[11],P4[11],sum3[12]);
	full_adder  FA7(carry5[14],sum5[14],P5[14],sum4[15],carry4[14]);
	full_adder  FA8(carry5[13],sum5[13],P5[13],sum4[14],carry4[13]);
	full_adder  FA9(carry5[12],sum5[12],P5[12],sum4[13],carry4[12]);
	full_adder  FA10(carry5[11],sum5[11],P5[11],sum4[12],carry4[11]);
	half_adder  HA1(carry5[10],sum5[10],P5[10],sum4[11]);
	full_adder  FA11(carry6[14],sum6[14],P6[14],sum5[15],carry5[14]);
	full_adder  FA12(carry6[13],sum6[13],P6[13],sum5[14],carry5[13]);
	full_adder  FA13(carry6[12],sum6[12],P6[12],sum5[13],carry5[12]);
	full_adder  FA14(carry6[11],sum6[11],P6[11],sum5[12],carry5[11]);
	full_adder  FA15(carry6[10],sum6[10],P6[10],sum5[11],carry5[10]);
	half_adder  HA2(carry6[9],sum6[9],P6[9],sum5[10]);
	full_adder  FA16(carry7[14],sum7[14],P7[14],sum6[15],carry6[14]);
	full_adder  FA17(carry7[13],sum7[13],P7[13],sum6[14],carry6[13]);
	full_adder  FA18(carry7[12],sum7[12],P7[12],sum6[13],carry6[12]);
	full_adder  FA19(carry7[11],sum7[11],P7[11],sum6[12],carry6[11]);
	full_adder  FA20(carry7[10],sum7[10],P7[10],sum6[11],carry6[10]);
	full_adder  FA21(carry7[9],sum7[9],P7[9],sum6[10],carry6[9]);
	half_adder  HA3(carry7[8],sum7[8],P7[8],sum6[9]);
	full_adder  FA22(carry8[14],sum8[14],P8[14],sum7[15],carry7[14]);
	full_adder  FA23(carry8[13],sum8[13],P8[13],sum7[14],carry7[13]);
	full_adder  FA24(carry8[12],sum8[12],P8[12],sum7[13],carry7[12]);
	full_adder  FA25(carry8[11],sum8[11],P8[11],sum7[12],carry7[11]);
	full_adder  FA26(carry8[10],sum8[10],P8[10],sum7[11],carry7[10]);
	full_adder  FA27(carry8[9],sum8[9],P8[9],sum7[10],carry7[9]);
	full_adder  FA28(carry8[8],sum8[8],P8[8],sum7[9],carry7[8]);
	half_adder  HA4(carry8[7],sum8[7],P8[7],sum7[8]);
	full_adder  FA29(carry9[14],sum9[14],P9[14],sum8[15],carry8[14]);
	full_adder  FA30(carry9[13],sum9[13],P9[13],sum8[14],carry8[13]);
	full_adder  FA31(carry9[12],sum9[12],P9[12],sum8[13],carry8[12]);
	full_adder  FA32(carry9[11],sum9[11],P9[11],sum8[12],carry8[11]);
	full_adder  FA33(carry9[10],sum9[10],P9[10],sum8[11],carry8[10]);
	full_adder  FA34(carry9[9],sum9[9],P9[9],sum8[10],carry8[9]);
	full_adder  FA35(carry9[8],sum9[8],P9[8],sum8[9],carry8[8]);
	full_adder  FA36(carry9[7],sum9[7],P9[7],sum8[8],carry8[7]);
	half_adder  HA5(carry9[6],sum9[6],P9[6],sum8[7]);
	full_adder  FA37(carry10[14],sum10[14],P10[14],sum9[15],carry9[14]);
	full_adder  FA38(carry10[13],sum10[13],P10[13],sum9[14],carry9[13]);
	full_adder  FA39(carry10[12],sum10[12],P10[12],sum9[13],carry9[12]);
	full_adder  FA40(carry10[11],sum10[11],P10[11],sum9[12],carry9[11]);
	full_adder  FA41(carry10[10],sum10[10],P10[10],sum9[11],carry9[10]);
	full_adder  FA42(carry10[9],sum10[9],P10[9],sum9[10],carry9[9]);
	full_adder  FA43(carry10[8],sum10[8],P10[8],sum9[9],carry9[8]);
	full_adder  FA44(carry10[7],sum10[7],P10[7],sum9[8],carry9[7]);
	full_adder  FA45(carry10[6],sum10[6],P10[6],sum9[7],carry9[6]);
	half_adder  HA6(carry10[5],sum10[5],P10[5],sum9[6]);
	full_adder  FA46(carry11[14],sum11[14],P11[14],sum10[15],carry10[14]);
	full_adder  FA47(carry11[13],sum11[13],P11[13],sum10[14],carry10[13]);
	full_adder  FA48(carry11[12],sum11[12],P11[12],sum10[13],carry10[12]);
	full_adder  FA49(carry11[11],sum11[11],P11[11],sum10[12],carry10[11]);
	full_adder  FA50(carry11[10],sum11[10],P11[10],sum10[11],carry10[10]);
	full_adder  FA51(carry11[9],sum11[9],P11[9],sum10[10],carry10[9]);
	full_adder  FA52(carry11[8],sum11[8],P11[8],sum10[9],carry10[8]);
	full_adder  FA53(carry11[7],sum11[7],P11[7],sum10[8],carry10[7]);
	full_adder  FA54(carry11[6],sum11[6],P11[6],sum10[7],carry10[6]);
	full_adder  FA55(carry11[5],sum11[5],P11[5],sum10[6],carry10[5]);
	half_adder  HA7(carry11[4],sum11[4],P11[4],sum10[5]);
	full_adder  FA56(carry12[14],sum12[14],P12[14],sum11[15],carry11[14]);
	full_adder  FA57(carry12[13],sum12[13],P12[13],sum11[14],carry11[13]);
	full_adder  FA58(carry12[12],sum12[12],P12[12],sum11[13],carry11[12]);
	full_adder  FA59(carry12[11],sum12[11],P12[11],sum11[12],carry11[11]);
	full_adder  FA60(carry12[10],sum12[10],P12[10],sum11[11],carry11[10]);
	full_adder  FA61(carry12[9],sum12[9],P12[9],sum11[10],carry11[9]);
	full_adder  FA62(carry12[8],sum12[8],P12[8],sum11[9],carry11[8]);
	full_adder  FA63(carry12[7],sum12[7],P12[7],sum11[8],carry11[7]);
	full_adder  FA64(carry12[6],sum12[6],P12[6],sum11[7],carry11[6]);
	full_adder  FA65(carry12[5],sum12[5],P12[5],sum11[6],carry11[5]);
	full_adder  FA66(carry12[4],sum12[4],P12[4],sum11[5],carry11[4]);
	half_adder  HA8(carry12[3],sum12[3],P12[3],sum11[4]);
	full_adder  FA67(carry13[14],sum13[14],P13[14],sum12[15],carry12[14]);
	full_adder  FA68(carry13[13],sum13[13],P13[13],sum12[14],carry12[13]);
	full_adder  FA69(carry13[12],sum13[12],P13[12],sum12[13],carry12[12]);
	full_adder  FA70(carry13[11],sum13[11],P13[11],sum12[12],carry12[11]);
	full_adder  FA71(carry13[10],sum13[10],P13[10],sum12[11],carry12[10]);
	full_adder  FA72(carry13[9],sum13[9],P13[9],sum12[10],carry12[9]);
	full_adder  FA73(carry13[8],sum13[8],P13[8],sum12[9],carry12[8]);
	full_adder  FA74(carry13[7],sum13[7],P13[7],sum12[8],carry12[7]);
	full_adder  FA75(carry13[6],sum13[6],P13[6],sum12[7],carry12[6]);
	full_adder  FA76(carry13[5],sum13[5],P13[5],sum12[6],carry12[5]);
	full_adder  FA77(carry13[4],sum13[4],P13[4],sum12[5],carry12[4]);
	full_adder  FA78(carry13[3],sum13[3],P13[3],sum12[4],carry12[3]);
	half_adder  HA9(carry13[2],sum13[2],P13[2],sum12[3]);
	full_adder  FA79(carry14[14],sum14[14],P14[14],sum13[15],carry13[14]);
	full_adder  FA80(carry14[13],sum14[13],P14[13],sum13[14],carry13[13]);
	full_adder  FA81(carry14[12],sum14[12],P14[12],sum13[13],carry13[12]);
	full_adder  FA82(carry14[11],sum14[11],P14[11],sum13[12],carry13[11]);
	full_adder  FA83(carry14[10],sum14[10],P14[10],sum13[11],carry13[10]);
	full_adder  FA84(carry14[9],sum14[9],P14[9],sum13[10],carry13[9]);
	full_adder  FA85(carry14[8],sum14[8],P14[8],sum13[9],carry13[8]);
	full_adder  FA86(carry14[7],sum14[7],P14[7],sum13[8],carry13[7]);
	full_adder  FA87(carry14[6],sum14[6],P14[6],sum13[7],carry13[6]);
	full_adder  FA88(carry14[5],sum14[5],P14[5],sum13[6],carry13[5]);
	full_adder  FA89(carry14[4],sum14[4],P14[4],sum13[5],carry13[4]);
	full_adder  FA90(carry14[3],sum14[3],P14[3],sum13[4],carry13[3]);
	full_adder  FA91(carry14[2],sum14[2],P14[2],sum13[3],carry13[2]);
	half_adder  HA10(carry14[1],sum14[1],P14[1],sum13[2]);
	full_adder  FA92(carry15[14],sum15[14],P15[14],sum14[15],carry14[14]);
	full_adder  FA93(carry15[13],sum15[13],P15[13],sum14[14],carry14[13]);
	full_adder  FA94(carry15[12],sum15[12],P15[12],sum14[13],carry14[12]);
	full_adder  FA95(carry15[11],sum15[11],P15[11],sum14[12],carry14[11]);
	full_adder  FA96(carry15[10],sum15[10],P15[10],sum14[11],carry14[10]);
	full_adder  FA97(carry15[9],sum15[9],P15[9],sum14[10],carry14[9]);
	full_adder  FA98(carry15[8],sum15[8],P15[8],sum14[9],carry14[8]);
	full_adder  FA99(carry15[7],sum15[7],P15[7],sum14[8],carry14[7]);
	full_adder  FA100(carry15[6],sum15[6],P15[6],sum14[7],carry14[6]);
	full_adder  FA101(carry15[5],sum15[5],P15[5],sum14[6],carry14[5]);
	full_adder  FA102(carry15[4],sum15[4],P15[4],sum14[5],carry14[4]);
	full_adder  FA103(carry15[3],sum15[3],P15[3],sum14[4],carry14[3]);
	full_adder  FA104(carry15[2],sum15[2],P15[2],sum14[3],carry14[2]);
	full_adder  FA105(carry15[1],sum15[1],P15[1],sum14[2],carry14[1]);
	assign carry15[0] = P15[0] & sum14[1];

	// Generate lower product bits YBITS 

	// Final Carry Propagate Addition
	//   Generate higher product bits
	half_adder CPA1(carry16[0],Z[0],carry15[0],sum15[1]);
	full_adder CPA2(carry16[1],Z[1],carry15[1],carry16[0],sum15[2]);
	full_adder CPA3(carry16[2],Z[2],carry15[2],carry16[1],sum15[3]);
	full_adder CPA4(carry16[3],Z[3],carry15[3],carry16[2],sum15[4]);
	full_adder CPA5(carry16[4],Z[4],carry15[4],carry16[3],sum15[5]);
	full_adder CPA6(carry16[5],Z[5],carry15[5],carry16[4],sum15[6]);
	full_adder CPA7(carry16[6],Z[6],carry15[6],carry16[5],sum15[7]);
	full_adder CPA8(carry16[7],Z[7],carry15[7],carry16[6],sum15[8]);
	full_adder CPA9(carry16[8],Z[8],carry15[8],carry16[7],sum15[9]);
	full_adder CPA10(carry16[9],Z[9],carry15[9],carry16[8],sum15[10]);
	full_adder CPA11(carry16[10],Z[10],carry15[10],carry16[9],sum15[11]);
	full_adder CPA12(carry16[11],Z[11],carry15[11],carry16[10],sum15[12]);
	full_adder CPA13(carry16[12],Z[12],carry15[12],carry16[11],sum15[13]);
	full_adder CPA14(carry16[13],Z[13],carry15[13],carry16[12],sum15[14]);
	full_adder CPA15(Z[15],Z[14],carry15[14],carry16[13],sum15[15]);
endmodule